home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 0.9.1.3 stable / flock-0.9.1.3.en-US.win32.exe / flock / chrome / browser.jar / content / browser / preferences / helperapplications.js < prev    next >
Text File  |  2006-07-18  |  28KB  |  785 lines
  1. //@line 38 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/preferences/helperapplications.js"
  2.  
  3. var gRDF;
  4.  
  5. const kPluginHandlerContractID = "@mozilla.org/content/plugin/document-loader-factory;1";
  6. const kDisabledPluginTypesPref = "plugin.disable_full_page_plugin_for_types";
  7. const kRootTypePrefix = "urn:mimetype:";
  8.  
  9. ///////////////////////////////////////////////////////////////////////////////
  10. // MIME Types DataSource Wrapper
  11.  
  12. function NC_URI(aProperty)
  13. {
  14.   return "http://home.netscape.com/NC-rdf#" + aProperty;
  15. }
  16.  
  17. function MIME_URI(aType)
  18. {
  19.   return "urn:mimetype:" + aType;
  20. }
  21.  
  22. function HANDLER_URI(aHandler)
  23. {
  24.   return "urn:mimetype:handler:" + aHandler;
  25. }
  26.  
  27. function APP_URI(aType)
  28. {
  29.   return "urn:mimetype:externalApplication:" + aType;
  30. }
  31.  
  32. function ArrayEnumerator(aItems)
  33. {
  34.   this._index = 0;
  35.   
  36.   if (aItems) {
  37.     for (var i = 0; i < aItems.length; ++i) {    
  38.       if (!aItems[i])
  39.         aItems.splice(i, 1);      
  40.     }
  41.   }
  42.   
  43.   this._contents = aItems || [];
  44.  
  45.   this.push = function (aElement) 
  46.   {
  47.     if (aElement)
  48.       this._contents.push(aElement);
  49.   };
  50.   
  51.   this.hasMoreElements = function ()
  52.   {
  53.     return this._index < this._contents.length;
  54.   };
  55.   
  56.   this.getNext = function ()
  57.   {
  58.     return this._contents[this._index++];      
  59.   };
  60. };
  61.  
  62. function HelperApps()
  63. {
  64.   if (!gRDF) {
  65.     gRDF = Components.classes["@mozilla.org/rdf/rdf-service;1"]
  66.                      .getService(Components.interfaces.nsIRDFService);
  67.   }
  68.   
  69.   const mimeTypes = "UMimTyp";
  70.   var fileLocator = Components.classes["@mozilla.org/file/directory_service;1"]
  71.                               .getService(Components.interfaces.nsIProperties);
  72.   
  73.   var file = fileLocator.get(mimeTypes, Components.interfaces.nsIFile);
  74.  
  75.   var ioService = Components.classes["@mozilla.org/network/io-service;1"]
  76.                             .getService(Components.interfaces.nsIIOService);
  77.   var fileHandler = ioService.getProtocolHandler("file")
  78.                              .QueryInterface(Components.interfaces.nsIFileProtocolHandler);
  79.   this._inner = gRDF.GetDataSourceBlocking(fileHandler.getURLSpecFromFile(file));
  80.   this._inner.AddObserver(this);
  81.  
  82.   this._fileTypeArc         = gRDF.GetResource(NC_URI("FileType"));
  83.   this._fileMimeTypeArc     = gRDF.GetResource(NC_URI("FileMIMEType"));
  84.   this._fileHandlerArc      = gRDF.GetResource(NC_URI("FileHandler"));
  85.   this._filePluginAvailable = gRDF.GetResource(NC_URI("FilePluginAvailable"));
  86.   this._fileHandledByPlugin = gRDF.GetResource(NC_URI("FileHandledByPlugin"));
  87.   this._fileIconArc         = gRDF.GetResource(NC_URI("FileIcon"));
  88.   this._largeFileIconArc    = gRDF.GetResource(NC_URI("LargeFileIcon"));
  89.   this._fileExtensionArc    = gRDF.GetResource(NC_URI("FileExtension"));
  90.   this._fileExtensionsArc   = gRDF.GetResource(NC_URI("FileExtensions"));
  91.   this._handleAutoArc       = gRDF.GetResource(NC_URI("FileHandleAuto"));
  92.   this._valueArc            = gRDF.GetResource(NC_URI("value"));
  93.   this._handlerPropArc      = gRDF.GetResource(NC_URI("handlerProp"));
  94.   this._externalAppArc      = gRDF.GetResource(NC_URI("externalApplication"));
  95.   this._childArc            = gRDF.GetResource(NC_URI("child"));
  96.   this._mimeTypes           = gRDF.GetResource("urn:mimetypes");
  97.   this._mimeTypesRoot       = gRDF.GetResource("urn:mimetypes:root");
  98.   
  99.   // Read enabled plugin type information from the category manager
  100.   var prefs = Components.classes["@mozilla.org/preferences-service;1"]
  101.                         .getService(Components.interfaces.nsIPrefBranch);
  102.   var disabled = "";
  103.   if (prefs.prefHasUserValue(kDisabledPluginTypesPref)) 
  104.     disabled = prefs.getCharPref(kDisabledPluginTypesPref);
  105.  
  106.   for (var i = 0; i < navigator.plugins.length; ++i) {
  107.     var plugin = navigator.plugins[i];
  108.     for (var j = 0; j < plugin.length; ++j) {
  109.       var currType = plugin[j].type;
  110.       this._availableTypes[currType] = { mimeURI: MIME_URI(currType),
  111.                                          pluginAvailable: true,
  112.                                          pluginEnabled: disabled.indexOf(currType) == -1 };
  113.     }
  114.   }
  115. }
  116.  
  117. HelperApps.prototype = {
  118.   _availableTypes: { },
  119.  
  120.   mimeHandlerExists: function (aMIMEType)
  121.   {
  122.     var valueProperty = gRDF.GetUnicodeResource(NC_URI("value"));
  123.     var mimeSource = gRDF.GetUnicodeResource(MIME_URI(aMIMEType));
  124.     var mimeLiteral = gRDF.GetLiteral(aMIMEType);
  125.     return this._inner.HasAssertion(mimeSource, valueProperty, mimeLiteral, true);
  126.   },
  127.  
  128.   updateTypeInfo: function (aMIMEInfo) 
  129.   {
  130.     var mimeType = aMIMEInfo.MIMEType;
  131.     var isNewMIMEType = this.mimeHandlerExists(mimeType);
  132.     var entry = new HandlerOverride(MIME_URI(mimeType), this._inner);
  133.     entry.mimeType    = mimeType;
  134.     entry.isEditable  = true;
  135.     entry.alwaysAsk = aMIMEInfo.alwaysAskBeforeHandling;
  136.     
  137.     // If not updating (i.e., a newly encountered mime type),
  138.     // then update extension list and description.
  139.     if (!isNewMIMEType) {
  140.       var extEnumerator = aMIMEInfo.getFileExtensions();
  141.       while (extEnumerator.hasMore()) {
  142.           entry.addExtension(extEnumerator.getNext());
  143.       }
  144.       entry.description = aMIMEInfo.description;
  145.       entry.appDisplayName = "";
  146.     }
  147.     
  148.     const nsIMIMEInfo = Components.interfaces.nsIMIMEInfo;
  149.     if (aMIMEInfo.preferredAction == nsIMIMEInfo.saveToDisk) {
  150.       entry.saveToDisk = true;
  151.       if (!isNewMIMEType) {
  152.         // Creating a new entry, set path.
  153.         entry.appPath = "";
  154.       }
  155.     } 
  156.     else if (aMIMEInfo.preferredAction == nsIMIMEInfo.useSystemDefault ||
  157.              aMIMEInfo.preferredApplicationHandler == null) {
  158.       entry.useSystemDefault = true;
  159.       if (!isNewMIMEType) {
  160.         // Creating a new entry, set path.
  161.         entry.appPath = "";
  162.       }
  163.     } 
  164.     else {
  165.       entry.saveToDisk       = false;
  166.       entry.useSystemDefault = false;
  167.       entry.handleInternal   = false;
  168.       entry.appPath = aMIMEInfo.preferredApplicationHandler.path;
  169.       entry.appDisplayName = aMIMEInfo.applicationDescription;
  170.     }
  171.     
  172.     // Do RDF magic.
  173.     entry.buildLinks();
  174.     this.flush();
  175.   },
  176.  
  177.   getLiteralValue: function (aResource, aProperty)
  178.   {
  179.     var res = gRDF.GetResource(aResource);
  180.     var prop = gRDF.GetResource(NC_URI(aProperty));
  181.     var val = this.GetTarget(res, prop, true);
  182.     if (val) {
  183.       val = val.QueryInterface(Components.interfaces.nsIRDFLiteral);
  184.       return val.Value;
  185.     }
  186.     return "";
  187.   },
  188.   
  189.   enableFullPagePluginForType: function (aContentType, aEnabled)
  190.   {
  191.     this._availableTypes[aContentType].pluginEnabled = aEnabled;
  192.   },
  193.  
  194.   /* nsIRDFDataSource */
  195.   get URI() {
  196.     return this._inner.URI;
  197.   },
  198.   
  199.   GetSource: function (aProperty, aTarget, aTruthValue) {
  200.     return this._inner.GetSource(aProperty, aTarget, aTruthValue);
  201.   },
  202.   GetSources: function (aProperty, aTarget, aTruthValue) {
  203.     return this._inner.GetSources(aProperty, aTarget, aTruthValue);
  204.   },         
  205.   
  206.   _isRootTypeResource: function (aResource) {
  207.     aResource = aResource.QueryInterface(Components.interfaces.nsIRDFResource);  
  208.     return (aResource.Value.substr(0, kRootTypePrefix.length) == kRootTypePrefix);
  209.   },
  210.   
  211.   _getTypeFromResource: function (aResource) {
  212.     var value = aResource.Value;
  213.     return value.substr(kRootTypePrefix.length, value.length);
  214.   },
  215.   
  216.   getMIMEInfo: function (aResource) {
  217.     var types = this._inner.GetTarget(aResource, this._valueArc, true);
  218.     var mimeSvc = Components.classes["@mozilla.org/uriloader/external-helper-app-service;1"]
  219.                             .getService(Components.interfaces.nsIMIMEService);
  220.     if (types) {
  221.       types = types.QueryInterface(Components.interfaces.nsIRDFLiteral);
  222.       types = types.Value.split(", ");
  223.       
  224.       // We're using helper app service as our MIME Service here because the helper app service
  225.       // talks to OS Specific hooks that on some platforms (MacOS X) are required to get a 
  226.       // fully populated MIME Info object. Thus it is this object that we return. 
  227.       return mimeSvc.getFromTypeAndExtension(types[0], null);
  228.     }
  229.     else {
  230.       var type = this._getTypeFromResource(aResource);
  231.       if (type in this._availableTypes && this._availableTypes[type].pluginAvailable)
  232.         return mimeSvc.getFromTypeAndExtension(type, null);
  233.     }
  234.     
  235.     return null;
  236.   },
  237.    
  238.   GetTarget: function (aSource, aProperty, aTruthValue) {
  239.     if (this._isRootTypeResource(aSource)) {
  240.       var typeInfo = this.getMIMEInfo(aSource);
  241.       if (typeInfo) {
  242.         dump("*** " + aSource.Value + " p = " + aProperty.Value + "\n");
  243.         var bundleUCT = document.getElementById("bundleUCT");
  244.         if (aProperty.EqualsNode(this._handleAutoArc)) {
  245.           var handler = this.GetTarget(aSource, this._handlerPropArc, true);
  246.           if (handler) {
  247.             dump("*** hashandler\n");
  248.             handler = handler.QueryInterface(Components.interfaces.nsIRDFResource);
  249.             return gRDF.GetLiteral(!(this.getLiteralValue(handler.Value, "alwaysAsk") == "true"));
  250.           }
  251.           dump("*** nohandler\n");
  252.           return gRDF.GetLiteral("true");
  253.         }
  254.         else if (aProperty.EqualsNode(this._fileTypeArc)) {
  255.           if (typeInfo.description == "") {
  256.             try {
  257.               var literal = bundleUCT.getFormattedString("fileEnding", [typeInfo.primaryExtension.toUpperCase()]);
  258.               return gRDF.GetLiteral(literal);
  259.             }
  260.             catch (e) { 
  261.               // Wow, this sucks, just show the MIME type as a last ditch effort to display
  262.               // the type of file that this is. 
  263.               return gRDF.GetLiteral(typeInfo.MIMEType);
  264.             }
  265.           }
  266.           return gRDF.GetLiteral(typeInfo.description);
  267.         }
  268.         else if (aProperty.EqualsNode(this._fileMimeTypeArc))
  269.           return gRDF.GetLiteral(typeInfo.MIMEType);
  270.         else if (aProperty.EqualsNode(this._fileHandlerArc)) {
  271.           // Look for a plugin handler first
  272.           if (this._availableTypes[typeInfo.MIMEType].pluginAvailable && 
  273.               this._availableTypes[typeInfo.MIMEType].pluginEnabled) {
  274.             for (var i = 0; i < navigator.plugins.length; ++i) {
  275.               var plugin = navigator.plugins[i];
  276.               for (var j = 0; j < plugin.length; ++j) {
  277.                 if (typeInfo.MIMEType == plugin[j].type)
  278.                   return gRDF.GetLiteral(bundleUCT.getFormattedString("openWith", [plugin.name]));
  279.               }
  280.             }
  281.           }
  282.           
  283.           var handler = this.GetTarget(aSource, this._handlerPropArc, true);
  284.           if (handler) {
  285.             handler = handler.QueryInterface(Components.interfaces.nsIRDFResource);
  286.             if (this.getLiteralValue(handler.Value, "saveToDisk") == "true") {
  287.               var saveToDisk = bundleUCT.getString("saveToDisk");
  288.               return gRDF.GetLiteral(saveToDisk);
  289.             }
  290.             else if (this.getLiteralValue(handler.Value, "useSystemDefault") == "false") {
  291.               var extApp = this.GetTarget(handler, this._externalAppArc, true);
  292.               if (extApp) {
  293.                 extApp = extApp.QueryInterface(Components.interfaces.nsIRDFResource);
  294.                 var openWith = bundleUCT.getFormattedString("openWith", [this.getLiteralValue(extApp.Value, "prettyName")]);
  295.                 return gRDF.GetLiteral(openWith);
  296.               }
  297.             }
  298.           }     
  299.           var openWith2 = bundleUCT.getFormattedString("openWith", [typeInfo.defaultDescription]);
  300.           return gRDF.GetLiteral(openWith2);
  301.         }
  302.         else if (aProperty.EqualsNode(this._filePluginAvailable)) {
  303.           var pluginAvailable = this._availableTypes[typeInfo.MIMEType].pluginAvailable;
  304.           return gRDF.GetLiteral(pluginAvailable ? "true" : "false");
  305.         }
  306.         else if (aProperty.EqualsNode(this._fileHandledByPlugin)) {
  307.           var handledByPlugin = (this._availableTypes[typeInfo.MIMEType].pluginAvailable && 
  308.                                  this._availableTypes[typeInfo.MIMEType].pluginEnabled);
  309.           return gRDF.GetLiteral(handledByPlugin ? "true" : "false");
  310.         }
  311.         else if (aProperty.EqualsNode(this._fileIconArc)) {
  312.           try {
  313.             return gRDF.GetLiteral("moz-icon://goat." + typeInfo.primaryExtension + "?size=16");
  314.           }
  315.           catch (e) { }
  316.           return gRDF.GetLiteral("moz-icon://goat?size=16&contentType=" + typeInfo.MIMEType);
  317.         }
  318.         else if (aProperty.EqualsNode(this._largeFileIconArc)) {
  319.           try {
  320.             return gRDF.GetLiteral("moz-icon://goat." + typeInfo.primaryExtension + "?size=32");
  321.           }
  322.           catch (e) { }
  323.           return gRDF.GetLiteral("moz-icon://goat?size=32&contentType=" + typeInfo.MIMEType);
  324.         }
  325.         else if (aProperty.EqualsNode(this._fileExtensionArc)) {
  326.           try {
  327.             return gRDF.GetLiteral(typeInfo.primaryExtension.toUpperCase());
  328.           }
  329.           catch (e) { }
  330.           return gRDF.GetLiteral(bundleUCT.getString("extensionNone"));
  331.         }
  332.         else if (aProperty.EqualsNode(this._fileExtensionsArc)) {
  333.           var extns = typeInfo.getFileExtensions();
  334.           
  335.           // Prevent duplicates.
  336.           var hash = { };
  337.           while (extns.hasMore())
  338.             hash[extns.getNext().toUpperCase()] = 0;
  339.           
  340.           var str = "";
  341.           for (var extn in hash)
  342.             str += extn + ",";
  343.           str = str.substring(0, str.length - 1);
  344.  
  345.           return gRDF.GetLiteral(str);
  346.         }
  347.       }
  348.     }
  349.  
  350.     return this._inner.GetTarget(aSource, aProperty, aTruthValue);
  351.   },      
  352.   
  353.   GetTargets: function (aSource, aProperty, aTruthValue) {
  354.     if (this._isRootTypeResource(aSource)) { 
  355.       return new ArrayEnumerator([this.GetTarget(aSource, aProperty, aTruthValue)]);
  356.     }
  357.     
  358.     if (aSource.EqualsNode(this._mimeTypes)) {
  359.       if (aProperty.EqualsNode(this._childArc)) {
  360.         var ctr = Components.classes["@mozilla.org/rdf/container;1"]
  361.                             .createInstance(Components.interfaces.nsIRDFContainer);
  362.         ctr.Init(this._inner, this._mimeTypesRoot);
  363.         var elements = ctr.GetElements();
  364.         while (elements.hasMoreElements()) {
  365.           var type = elements.getNext().QueryInterface(Components.interfaces.nsIRDFResource);
  366.           var mi = this.getMIMEInfo(type);
  367.           if (!(mi.MIMEType in this._availableTypes)) {
  368.             this._availableTypes[mi.MIMEType] = { mimeURI: MIME_URI(mi.MIMEType),
  369.                                                   pluginAvailable: false,
  370.                                                   pluginEnabled: false };
  371.           }
  372.         }
  373.         var types = [];
  374.         for (var type in this._availableTypes)
  375.           types.push(gRDF.GetResource(this._availableTypes[type].mimeURI));
  376.         return new ArrayEnumerator(types);
  377.       }
  378.       return new ArrayEnumerator([]);
  379.     }
  380.     
  381.     return this._inner.GetTargets(aSource, aProperty, aTruthValue);
  382.   }, 
  383.   Assert: function (aSource, aProperty, aTarget, aTruthValue) {
  384.     return this._inner.Assert(aSource, aProperty, aTarget, aTruthValue);
  385.   },
  386.   Unassert: function (aSource, aProperty, aTarget) {
  387.     return this._inner.Unassert(aSource, aProperty, aTarget);
  388.   },
  389.   Change: function (aSource, aProperty, aOldTarget, aNewTarget) {
  390.     if (aOldTarget)
  391.       var ot = aOldTarget.QueryInterface(Components.interfaces.nsIRDFLiteral);
  392.     if (aNewTarget)
  393.       var nt = aNewTarget.QueryInterface(Components.interfaces.nsIRDFLiteral);
  394.  
  395.     return this._inner.Change(aSource, aProperty, aOldTarget, aNewTarget);
  396.   },
  397.   Move: function (aOldSource, aNewSource, aProperty, aTarget) {
  398.     return this._inner.Assert(aOldSource, aNewSource, aProperty, aTarget);
  399.   },
  400.   HasAssertion: function (aSource, aProperty, aTarget, aTruthValue) {
  401.     if (this._isRootTypeResource(aSource)) {
  402.       // Don't show entries in the list for types that we DO NOT handle
  403.       // automatically. i.e. this list is a means of editing and removing
  404.       // automatic overrides only. 
  405.       if (aProperty.EqualsNode(this._handleAutoArc)) {
  406.         var handler = this.GetTarget(aSource, this._handlerPropArc, true);
  407.         if (handler) {
  408.           handler = handler.QueryInterface(Components.interfaces.nsIRDFResource);
  409.           return !(this.getLiteralValue(handler.Value, "alwaysAsk") == "true");
  410.         }
  411.         else {
  412.           // If there is no handler, at check to see if this type is handled
  413.           // by a full-page plugin, and that that full page plugin mode is
  414.           // enabled...
  415.           var type = this._getTypeFromResource(aSource);
  416.           if (type in this._availableTypes && 
  417.               this._availableTypes[type].pluginAvailable && 
  418.               type != "*" && type != "none")
  419.             return true;
  420.         } 
  421.       }
  422.     }
  423.     return this._inner.HasAssertion(aSource, aProperty, aTarget, aTruthValue);
  424.   },
  425.   AddObserver: function (aObserver) {
  426.     this._inner.AddObserver(aObserver);
  427.   },
  428.   RemoveObserver: function (aObserver) {
  429.     this._inner.RemoveObserver(aObserver);
  430.   },
  431.   ArcLabelsIn: function (aNode) {
  432.     return this._inner.ArcLabelsIn(aNode);
  433.   },
  434.   ArcLabelsOut: function (aNode) {
  435.     return this._inner.ArcLabelsOut(aNode);
  436.   },
  437.   GetAllResources: function () {
  438.     return this._inner.GetAllResources();
  439.   },
  440.   hasArcIn: function (aNode, aArc) {
  441.     return this._inner.hasArcIn(aNode, aArc);
  442.   },
  443.   hasArcOut: function (aNode, aArc) {
  444.     return this._inner.hasArcOut(aNode, aArc);
  445.   },
  446.   
  447.   _observers: [],
  448.   AddObserver: function (aObserver) {
  449.     this._observers.push(aObserver);
  450.   },
  451.   
  452.   RemoveObserver: function (aObserver) {
  453.     for (var i = 0; i < this._observers.length; ++i) {
  454.       if (this._observers[i] == aObserver) {
  455.         this._observers.splice(i, 1);
  456.         break;
  457.       }
  458.     }
  459.   },
  460.   
  461.   onAssert: function (aDataSource, aSource, aProperty, aTarget) {
  462.     for (var i = 0; i < this._observers.length; ++i)
  463.       this._observers[i].onAssert(aDataSource, aSource, aProperty, aTarget);
  464.   },
  465.  
  466.   onUnassert: function (aDataSource, aSource, aProperty, aTarget) {
  467.     for (var i = 0; i < this._observers.length; ++i)
  468.       this._observers[i].onUnassert(aDataSource, aSource, aProperty, aTarget);
  469.   },
  470.   
  471.   onChange: function (aDataSource, aSource, aProperty, aOldTarget, aNewTarget) {
  472.     for (var i = 0; i < this._observers.length; ++i)
  473.       this._observers[i].onChange(aDataSource, aSource, aProperty, aOldTarget, aNewTarget);
  474.   },
  475.   
  476.   onMove: function (aDataSource, aOldSource, aNewSource, aProperty, aTarget) {
  477.     for (var i = 0; i < this._observers.length; ++i)
  478.       this._observers[i].onMove(aDataSource, aOldSource, aNewSource, aProperty, aTarget);
  479.   },
  480.   
  481.   beginUpdateBatch: function (aDataSource) {
  482.     for (var i = 0; i < this._observers.length; ++i)
  483.       this._observers[i].beginUpdateBatch(aDataSource);
  484.   },
  485.   
  486.   endUpdateBatch: function (aDataSource) {
  487.     for (var i = 0; i < this._observers.length; ++i)
  488.       this._observers[i].endUpdateBatch(aDataSource);
  489.   },
  490.  
  491.   flush: function () {
  492.     var rds = this._inner.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
  493.     if (rds) 
  494.       rds.Flush();
  495.   },
  496.   
  497.   destroy: function () {
  498.     this._inner.RemoveObserver(this);
  499.   },
  500.   
  501.   QueryInterface: function nsExtensionManager_QueryInterface (aIID) 
  502.   {
  503.     if (!aIID.equals(Components.interfaces.nsIRDFRemoteDataSource) &&
  504.         !aIID.equals(Components.interfaces.nsIRDFDataSource) &&
  505.         !aIID.equals(Components.interfaces.nsIRDFObserver) &&
  506.         !aIID.equals(Components.interfaces.nsISupports))
  507.       throw Components.results.NS_ERROR_NO_INTERFACE;
  508.     return this;
  509.   }  
  510. };
  511.  
  512. /**
  513.  * Handler Override class
  514.  **/
  515. function HandlerOverride(aURI, aDatasource)
  516. {
  517.   this.URI = aURI;
  518.   this._DS = aDatasource;
  519. }
  520.  
  521. HandlerOverride.prototype = {
  522.   // general information
  523.   get mimeType()
  524.   {
  525.     return this.getLiteralForContentType(this.URI, "value");
  526.   },
  527.   
  528.   set mimeType(aMIMETypeString)
  529.   {
  530.     this.changeMIMEStuff(MIME_URI(aMIMETypeString), "value", aMIMETypeString.toLowerCase());
  531.     return aMIMETypeString;
  532.   },
  533.   
  534.   get description()
  535.   {
  536.     return this.getLiteralForContentType(this.URI, "description");
  537.   },  
  538.   
  539.   set description(aDescriptionString)
  540.   {
  541.     this.changeMIMEStuff(MIME_URI(this.mimeType), "description", aDescriptionString);
  542.     return aDescriptionString;
  543.   },
  544.   
  545.   get isEditable()
  546.   {
  547.     return this.getLiteralForContentType(this.URI, "editable");
  548.   },
  549.   
  550.   set isEditable(aIsEditableString)
  551.   {
  552.     this.changeMIMEStuff(MIME_URI(this.mimeType), "editable", aIsEditableString);
  553.     return aIsEditableString;
  554.   },
  555.  
  556.   get extensions()
  557.   {
  558.     var extensionResource = gRDF.GetUnicodeResource(NC_URI("fileExtensions"));
  559.     var contentTypeResource = gRDF.GetUnicodeResource(MIME_URI(this.mimeType));
  560.     var extensionTargets = this._DS.GetTargets(contentTypeResource, extensionResource, true);
  561.     var extString = "";
  562.     if (extensionTargets) {
  563.       while (extensionTargets.hasMoreElements()) {
  564.         var currentExtension = extensionTargets.getNext();
  565.         if (currentExtension) {
  566.           currentExtension = currentExtension.QueryInterface(Components.interfaces.nsIRDFLiteral);
  567.           if (extString != "") {
  568.             extString += " ";
  569.           }
  570.           extString += currentExtension.Value.toLowerCase();
  571.         }
  572.       }
  573.     }
  574.     return extString;
  575.   },
  576.   
  577.   addExtension: function (aExtensionString)
  578.   {
  579.     this.assertMIMEStuff(MIME_URI(this.mimeType), "fileExtensions", aExtensionString.toLowerCase());
  580.   },
  581.   
  582.   removeExtension: function (aExtensionString)
  583.   {
  584.     this.unassertMIMEStuff(MIME_URI(this.mimeType), "fileExtensions", aExtensionString.toLowerCase());
  585.   },
  586.  
  587.   clearExtensions: function ()
  588.   {
  589.     var extArray = this.extensions.split(" ");
  590.     for (i = extArray.length - 1; i >= 0; --i) {
  591.       this.removeExtension(extArray[i]);
  592.     }
  593.   },
  594.   
  595.   // content handling
  596.   get saveToDisk()
  597.   {
  598.     return this.getHandlerInfoForType(this.URI, "saveToDisk");
  599.   },
  600.   
  601.   set saveToDisk(aSavedToDisk)
  602.   {
  603.     this.changeMIMEStuff(HANDLER_URI(this.mimeType), "saveToDisk", aSavedToDisk);
  604.     this.setHandlerProcedure("handleInternal", "false");
  605.     this.setHandlerProcedure("useSystemDefault", "false");
  606.     return aSavedToDisk;
  607.  },
  608.  
  609.   get useSystemDefault()
  610.   {
  611.     return this.getHandlerInfoForType(this.URI, "useSystemDefault");
  612.   },
  613.  
  614.   set useSystemDefault(aUseSystemDefault)
  615.   {
  616.     this.changeMIMEStuff(HANDLER_URI(this.mimeType), "useSystemDefault", aUseSystemDefault);
  617.     this.setHandlerProcedure("handleInternal", "false");
  618.     this.setHandlerProcedure("saveToDisk", "false");
  619.     return aUseSystemDefault;
  620.   },
  621.   
  622.   get handleInternal()
  623.   {
  624.     return this.getHandlerInfoForType(this.URI, "handleInternal");
  625.   },
  626.   
  627.   set handleInternal(aHandledInternally)
  628.   {
  629.     this.changeMIMEStuff(HANDLER_URI(this.mimeType), "handleInternal", aHandledInternally);
  630.     this.setHandlerProcedure("saveToDisk", "false");
  631.     this.setHandlerProcedure("useSystemDefault", "false");
  632.     return aHandledInternally;
  633.   },
  634.  
  635.   setHandlerProcedure: function (aHandlerProcedure, aValue)
  636.   {
  637.     var handlerSource = gRDF.GetUnicodeResource(HANDLER_URI(this.mimeType));
  638.     var handlerProperty = gRDF.GetUnicodeResource(NC_URI(aHandlerProcedure));
  639.     var oppositeValue = aValue == "false" ? "true" : "false";
  640.     var trueLiteral = gRDF.GetLiteral(oppositeValue);
  641.     var hasCounterpart = this._DS.HasAssertion(handlerSource, handlerProperty, trueLiteral, true);
  642.     if (hasCounterpart) {
  643.       var falseLiteral = gRDF.GetLiteral(aValue);
  644.       this._DS.Change(handlerSource, handlerProperty, trueLiteral, falseLiteral);
  645.     }
  646.   },
  647.   
  648.   get alwaysAsk()
  649.   {
  650.     return this.getHandlerInfoForType(this.URI, "alwaysAsk");
  651.   },
  652.   
  653.   set alwaysAsk(aAlwaysAsk)
  654.   {
  655.     this.changeMIMEStuff(HANDLER_URI(this.mimeType), "alwaysAsk", aAlwaysAsk);
  656.     return aAlwaysAsk;
  657.   },
  658.   
  659.   // helper application
  660.   get appDisplayName()
  661.   {
  662.     return getHelperAppInfoForType(this.URI, "prettyName");
  663.   },
  664.   
  665.   set appDisplayName(aDisplayName)
  666.   {
  667.     this.changeMIMEStuff(APP_URI(this.mimeType), "prettyName", aDisplayName);
  668.     return aDisplayName;
  669.   },
  670.   
  671.   get appPath()
  672.   {
  673.     return this.getHelperAppInfoForType(this.URI, "path");
  674.   },
  675.   
  676.   set appPath(aAppPath)
  677.   {
  678.     this.changeMIMEStuff(APP_URI(this.mimeType), "path", aAppPath);
  679.     return aAppPath;
  680.   },
  681.  
  682.   /**
  683.    * After setting the various properties on this override, we need to
  684.    * build the links between the mime type resource, the handler for that
  685.    * resource, and the helper app (if any) associated with the resource.
  686.    * We also need to add this mime type to the RDF seq (list) of types.
  687.    **/
  688.   buildLinks: function()
  689.   {
  690.     // assert the handler resource
  691.     var mimeSource = gRDF.GetUnicodeResource(MIME_URI(this.mimeType));
  692.     var handlerProperty = gRDF.GetUnicodeResource(NC_URI("handlerProp"));
  693.     var handlerResource = gRDF.GetUnicodeResource(HANDLER_URI(this.mimeType));
  694.     this._DS.Assert(mimeSource, handlerProperty, handlerResource, true);
  695.     // assert the helper app resource
  696.     var helperAppProperty = gRDF.GetUnicodeResource(NC_URI("externalApplication"));
  697.     var helperAppResource = gRDF.GetUnicodeResource(APP_URI(this.mimeType));
  698.     this._DS.Assert(handlerResource, helperAppProperty, helperAppResource, true);
  699.     // add the mime type to the MIME types seq
  700.     var container = Components.classes["@mozilla.org/rdf/container;1"].createInstance();
  701.     if (container) {
  702.       container = container.QueryInterface(Components.interfaces.nsIRDFContainer);
  703.       if (container) {
  704.         var containerRes = gRDF.GetUnicodeResource("urn:mimetypes:root");
  705.         container.Init(this._DS, containerRes);
  706.         var element = gRDF.GetUnicodeResource(MIME_URI(this.mimeType));
  707.         if (container.IndexOf(element) == -1)
  708.           container.AppendElement(element);
  709.       }
  710.     }
  711.   }, 
  712.   
  713.   // Implementation helper methods
  714.   
  715.   getLiteralForContentType: function (aURI, aProperty)
  716.   {
  717.     var contentTypeResource = gRDF.GetUnicodeResource(aURI);
  718.     var propertyResource = gRDF.GetUnicodeResource(NC_URI(aProperty));
  719.     return this.getLiteral(contentTypeResource, propertyResource);
  720.   },
  721.  
  722.   getLiteral: function (aSource, aProperty)
  723.   {
  724.     var node = this._DS.GetTarget(aSource, aProperty, true);
  725.     if (node) {
  726.       node = node.QueryInterface(Components.interfaces.nsIRDFLiteral);
  727.       return node.Value;
  728.     }
  729.     return "";
  730.   },
  731.  
  732.   getHandlerInfoForType: function (aURI, aPropertyString)
  733.   {
  734.     // get current selected type
  735.     var handler = HANDLER_URI(this.getLiteralForContentType(aURI, "value"));
  736.     var source = gRDF.GetUnicodeResource(handler);
  737.     var property = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  738.     var target = this._DS.GetTarget(source, property, true);
  739.     if (target) {
  740.       target = target.QueryInterface(Components.interfaces.nsIRDFLiteral);
  741.       return target.Value;
  742.     }
  743.     return "";
  744.   },
  745.  
  746.   getHelperAppInfoForType: function (aURI, aPropertyString)
  747.   {
  748.     var appURI      = APP_URI(this.getLiteralForContentType(aURI, "value"));
  749.     var appRes      = gRDF.GetUnicodeResource(appURI);
  750.     var appProperty = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  751.     return getLiteral(appRes, appProperty);
  752.   },
  753.  
  754.   // write to the ds
  755.   assertMIMEStuff: function (aMIMEString, aPropertyString, aValueString)
  756.   {
  757.     var mimeSource = gRDF.GetUnicodeResource(aMIMEString);
  758.     var valueProperty = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  759.     var mimeLiteral = gRDF.GetLiteral(aValueString);
  760.     this._DS.Assert(mimeSource, valueProperty, mimeLiteral, true);
  761.   },
  762.  
  763.   changeMIMEStuff: function(aMIMEString, aPropertyString, aValueString)
  764.   {
  765.     var mimeSource = gRDF.GetUnicodeResource(aMIMEString);
  766.     var valueProperty = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  767.     var mimeLiteral = gRDF.GetLiteral(aValueString);
  768.     var currentValue = this._DS.GetTarget(mimeSource, valueProperty, true);
  769.     if (currentValue) {
  770.       this._DS.Change(mimeSource, valueProperty, currentValue, mimeLiteral);
  771.     } else {
  772.       this._DS.Assert(mimeSource, valueProperty, mimeLiteral, true);
  773.     } 
  774.   },
  775.  
  776.   unassertMIMEStuff: function(aMIMEString, aPropertyString, aValueString)
  777.   {
  778.     var mimeSource = gRDF.GetUnicodeResource(aMIMEString);
  779.     var valueProperty = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  780.     var mimeLiteral = gRDF.GetLiteral(aValueString);
  781.     this._DS.Unassert(mimeSource, valueProperty, mimeLiteral, true);
  782.   }
  783. };
  784.  
  785.